<?php


/**
 * Base class that represents a query for the 'reports_total' table.
 *
 *
 *
 * @method DamagesReportsTotalQuery orderBySzkodaId($order = Criteria::ASC) Order by the szkoda_id column
 * @method DamagesReportsTotalQuery orderByDataZgloszeniaSzkody($order = Criteria::ASC) Order by the data_zgloszenia_szkody column
 * @method DamagesReportsTotalQuery orderByDataUszkodzenia($order = Criteria::ASC) Order by the data_uszkodzenia column
 * @method DamagesReportsTotalQuery orderByDataZgloszeniaDealera($order = Criteria::ASC) Order by the data_zgloszenia_dealera column
 * @method DamagesReportsTotalQuery orderBySamochodId($order = Criteria::ASC) Order by the samochod_id column
 * @method DamagesReportsTotalQuery orderBySamochodVin($order = Criteria::ASC) Order by the samochod_vin column
 * @method DamagesReportsTotalQuery orderBySamochodNazwa($order = Criteria::ASC) Order by the samochod_nazwa column
 * @method DamagesReportsTotalQuery orderBySamochodNrKomisji($order = Criteria::ASC) Order by the samochod_nr_komisji column
 * @method DamagesReportsTotalQuery orderByStatusNazwa($order = Criteria::ASC) Order by the status_nazwa column
 * @method DamagesReportsTotalQuery orderByMarkaKod($order = Criteria::ASC) Order by the marka_kod column
 * @method DamagesReportsTotalQuery orderByMarkaNazwa($order = Criteria::ASC) Order by the marka_nazwa column
 * @method DamagesReportsTotalQuery orderByDealerNumer($order = Criteria::ASC) Order by the dealer_numer column
 * @method DamagesReportsTotalQuery orderByDealerMiasto($order = Criteria::ASC) Order by the dealer_miasto column
 * @method DamagesReportsTotalQuery orderByUszkodzenieRodzajKod($order = Criteria::ASC) Order by the uszkodzenie_rodzaj_kod column
 * @method DamagesReportsTotalQuery orderByUszkodzenieRodzajNazwa($order = Criteria::ASC) Order by the uszkodzenie_rodzaj_nazwa column
 * @method DamagesReportsTotalQuery orderByUszkodzenieMiejsceKod($order = Criteria::ASC) Order by the uszkodzenie_miejsce_kod column
 * @method DamagesReportsTotalQuery orderByUszkodzenieMiejsceNazwa($order = Criteria::ASC) Order by the uszkodzenie_miejsce_nazwa column
 * @method DamagesReportsTotalQuery orderByUszkodzenieRozmiarKod($order = Criteria::ASC) Order by the uszkodzenie_rozmiar_kod column
 * @method DamagesReportsTotalQuery orderByUszkodzenieRozmiarNazwa($order = Criteria::ASC) Order by the uszkodzenie_rozmiar_nazwa column
 * @method DamagesReportsTotalQuery orderByKosztorysWartosc($order = Criteria::ASC) Order by the kosztorys_wartosc column
 * @method DamagesReportsTotalQuery orderByKosztorysUpustFlaga($order = Criteria::ASC) Order by the kosztorys_upust_flaga column
 * @method DamagesReportsTotalQuery orderByKosztorysUpustWartosc($order = Criteria::ASC) Order by the kosztorys_upust_wartosc column
 * @method DamagesReportsTotalQuery orderByKosztorysUpustProcent($order = Criteria::ASC) Order by the kosztorys_upust_procent column
 * @method DamagesReportsTotalQuery orderByKosztorysWartoscSamochodu($order = Criteria::ASC) Order by the kosztorys_wartosc_samochodu column
 * @method DamagesReportsTotalQuery orderByKosztorysWartoscOdliczenie($order = Criteria::ASC) Order by the kosztorys_wartosc_odliczenia column
 * @method DamagesReportsTotalQuery orderByKosztorysDataDodania($order = Criteria::ASC) Order by the kosztorys_data_dodania column
 * @method DamagesReportsTotalQuery orderByTypNazwa($order = Criteria::ASC) Order by the typ_nazwa column
 * @method DamagesReportsTotalQuery orderByTypTransportu($order = Criteria::ASC) Order by the typ_transportu column
 * @method DamagesReportsTotalQuery orderByFakturaId($order = Criteria::ASC) Order by the faktura_id column
 * @method DamagesReportsTotalQuery orderByFakturaWartoscSuma($order = Criteria::ASC) Order by the faktura_wartosc_suma column
 * @method DamagesReportsTotalQuery orderByFakturaDataDodania($order = Criteria::ASC) Order by the faktura_data_dodania column
 * @method DamagesReportsTotalQuery orderByNotaZaSzkodeWartoscSuma($order = Criteria::ASC) Order by the nota_za_szkode_wartosc_suma column
 * @method DamagesReportsTotalQuery orderByNotaZaSzkodeDataDodania($order = Criteria::ASC) Order by the nota_za_szkode_data_dodania column
 * @method DamagesReportsTotalQuery orderByNotaZaUtrateWartosciWartoscSuma($order = Criteria::ASC) Order by the nota_za_utrate_wartosci_wartosc_suma column
 * @method DamagesReportsTotalQuery orderByNotaZaUtrateWartosciDataDodania($order = Criteria::ASC) Order by the nota_za_utrate_wartosci_data_dodania column
 * @method DamagesReportsTotalQuery orderByProwadzacyImie($order = Criteria::ASC) Order by the prowadzacy_imie column
 * @method DamagesReportsTotalQuery orderByProwadzacyNazwisko($order = Criteria::ASC) Order by the prowadzacy_nazwisko column
 * @method DamagesReportsTotalQuery orderByOpisUszkodzenia($order = Criteria::ASC) Order by the opis_uszkodzenia column
 * @method DamagesReportsTotalQuery orderByUwagi($order = Criteria::ASC) Order by the uwagi column
 *
 * @method DamagesReportsTotalQuery groupBySzkodaId() Group by the szkoda_id column
 * @method DamagesReportsTotalQuery groupByDataZgloszeniaSzkody() Group by the data_zgloszenia_szkody column
 * @method DamagesReportsTotalQuery groupByDataUszkodzenia() Group by the data_uszkodzenia column
 * @method DamagesReportsTotalQuery groupByDataZgloszeniaDealera() Group by the data_zgloszenia_dealera column
 * @method DamagesReportsTotalQuery groupBySamochodId() Group by the samochod_id column
 * @method DamagesReportsTotalQuery groupBySamochodVin() Group by the samochod_vin column
 * @method DamagesReportsTotalQuery groupBySamochodNazwa() Group by the samochod_nazwa column
 * @method DamagesReportsTotalQuery groupBySamochodNrKomisji() Group by the samochod_nr_komisji column
 * @method DamagesReportsTotalQuery groupByStatusNazwa() Group by the status_nazwa column
 * @method DamagesReportsTotalQuery groupByMarkaKod() Group by the marka_kod column
 * @method DamagesReportsTotalQuery groupByMarkaNazwa() Group by the marka_nazwa column
 * @method DamagesReportsTotalQuery groupByDealerNumer() Group by the dealer_numer column
 * @method DamagesReportsTotalQuery groupByDealerMiasto() Group by the dealer_miasto column
 * @method DamagesReportsTotalQuery groupByUszkodzenieRodzajKod() Group by the uszkodzenie_rodzaj_kod column
 * @method DamagesReportsTotalQuery groupByUszkodzenieRodzajNazwa() Group by the uszkodzenie_rodzaj_nazwa column
 * @method DamagesReportsTotalQuery groupByUszkodzenieMiejsceKod() Group by the uszkodzenie_miejsce_kod column
 * @method DamagesReportsTotalQuery groupByUszkodzenieMiejsceNazwa() Group by the uszkodzenie_miejsce_nazwa column
 * @method DamagesReportsTotalQuery groupByUszkodzenieRozmiarKod() Group by the uszkodzenie_rozmiar_kod column
 * @method DamagesReportsTotalQuery groupByUszkodzenieRozmiarNazwa() Group by the uszkodzenie_rozmiar_nazwa column
 * @method DamagesReportsTotalQuery groupByKosztorysWartosc() Group by the kosztorys_wartosc column
 * @method DamagesReportsTotalQuery groupByKosztorysUpustFlaga() Group by the kosztorys_upust_flaga column
 * @method DamagesReportsTotalQuery groupByKosztorysUpustWartosc() Group by the kosztorys_upust_wartosc column
 * @method DamagesReportsTotalQuery groupByKosztorysUpustProcent() Group by the kosztorys_upust_procent column
 * @method DamagesReportsTotalQuery groupByKosztorysWartoscSamochodu() Group by the kosztorys_wartosc_samochodu column
 * @method DamagesReportsTotalQuery groupByKosztorysWartoscOdliczenie() Group by the kosztorys_wartosc_odliczenia column
 * @method DamagesReportsTotalQuery groupByKosztorysDataDodania() Group by the kosztorys_data_dodania column
 * @method DamagesReportsTotalQuery groupByTypNazwa() Group by the typ_nazwa column
 * @method DamagesReportsTotalQuery groupByTypTransportu() Group by the typ_transportu column
 * @method DamagesReportsTotalQuery groupByFakturaId() Group by the faktura_id column
 * @method DamagesReportsTotalQuery groupByFakturaWartoscSuma() Group by the faktura_wartosc_suma column
 * @method DamagesReportsTotalQuery groupByFakturaDataDodania() Group by the faktura_data_dodania column
 * @method DamagesReportsTotalQuery groupByNotaZaSzkodeWartoscSuma() Group by the nota_za_szkode_wartosc_suma column
 * @method DamagesReportsTotalQuery groupByNotaZaSzkodeDataDodania() Group by the nota_za_szkode_data_dodania column
 * @method DamagesReportsTotalQuery groupByNotaZaUtrateWartosciWartoscSuma() Group by the nota_za_utrate_wartosci_wartosc_suma column
 * @method DamagesReportsTotalQuery groupByNotaZaUtrateWartosciDataDodania() Group by the nota_za_utrate_wartosci_data_dodania column
 * @method DamagesReportsTotalQuery groupByProwadzacyImie() Group by the prowadzacy_imie column
 * @method DamagesReportsTotalQuery groupByProwadzacyNazwisko() Group by the prowadzacy_nazwisko column
 * @method DamagesReportsTotalQuery groupByOpisUszkodzenia() Group by the opis_uszkodzenia column
 * @method DamagesReportsTotalQuery groupByUwagi() Group by the uwagi column
 *
 * @method DamagesReportsTotalQuery leftJoin($relation) Adds a LEFT JOIN clause to the query
 * @method DamagesReportsTotalQuery rightJoin($relation) Adds a RIGHT JOIN clause to the query
 * @method DamagesReportsTotalQuery innerJoin($relation) Adds a INNER JOIN clause to the query
 *
 * @method DamagesReportsTotal findOne(PropelPDO $con = null) Return the first DamagesReportsTotal matching the query
 * @method DamagesReportsTotal findOneOrCreate(PropelPDO $con = null) Return the first DamagesReportsTotal matching the query, or a new DamagesReportsTotal object populated from the query conditions when no match is found
 *
 * @method DamagesReportsTotal findOneBySzkodaId(int $szkoda_id) Return the first DamagesReportsTotal filtered by the szkoda_id column
 * @method DamagesReportsTotal findOneByDataZgloszeniaSzkody(string $data_zgloszenia_szkody) Return the first DamagesReportsTotal filtered by the data_zgloszenia_szkody column
 * @method DamagesReportsTotal findOneByDataUszkodzenia(string $data_uszkodzenia) Return the first DamagesReportsTotal filtered by the data_uszkodzenia column
 * @method DamagesReportsTotal findOneByDataZgloszeniaDealera(string $data_zgloszenia_dealera) Return the first DamagesReportsTotal filtered by the data_zgloszenia_dealera column
 * @method DamagesReportsTotal findOneBySamochodId(int $samochod_id) Return the first DamagesReportsTotal filtered by the samochod_id column
 * @method DamagesReportsTotal findOneBySamochodVin(string $samochod_vin) Return the first DamagesReportsTotal filtered by the samochod_vin column
 * @method DamagesReportsTotal findOneBySamochodNazwa(string $samochod_nazwa) Return the first DamagesReportsTotal filtered by the samochod_nazwa column
 * @method DamagesReportsTotal findOneBySamochodNrKomisji(string $samochod_nr_komisji) Return the first DamagesReportsTotal filtered by the samochod_nr_komisji column
 * @method DamagesReportsTotal findOneByStatusNazwa(string $status_nazwa) Return the first DamagesReportsTotal filtered by the status_nazwa column
 * @method DamagesReportsTotal findOneByMarkaKod(string $marka_kod) Return the first DamagesReportsTotal filtered by the marka_kod column
 * @method DamagesReportsTotal findOneByMarkaNazwa(string $marka_nazwa) Return the first DamagesReportsTotal filtered by the marka_nazwa column
 * @method DamagesReportsTotal findOneByDealerNumer(string $dealer_numer) Return the first DamagesReportsTotal filtered by the dealer_numer column
 * @method DamagesReportsTotal findOneByDealerMiasto(string $dealer_miasto) Return the first DamagesReportsTotal filtered by the dealer_miasto column
 * @method DamagesReportsTotal findOneByUszkodzenieRodzajKod(string $uszkodzenie_rodzaj_kod) Return the first DamagesReportsTotal filtered by the uszkodzenie_rodzaj_kod column
 * @method DamagesReportsTotal findOneByUszkodzenieRodzajNazwa(string $uszkodzenie_rodzaj_nazwa) Return the first DamagesReportsTotal filtered by the uszkodzenie_rodzaj_nazwa column
 * @method DamagesReportsTotal findOneByUszkodzenieMiejsceKod(string $uszkodzenie_miejsce_kod) Return the first DamagesReportsTotal filtered by the uszkodzenie_miejsce_kod column
 * @method DamagesReportsTotal findOneByUszkodzenieMiejsceNazwa(string $uszkodzenie_miejsce_nazwa) Return the first DamagesReportsTotal filtered by the uszkodzenie_miejsce_nazwa column
 * @method DamagesReportsTotal findOneByUszkodzenieRozmiarKod(string $uszkodzenie_rozmiar_kod) Return the first DamagesReportsTotal filtered by the uszkodzenie_rozmiar_kod column
 * @method DamagesReportsTotal findOneByUszkodzenieRozmiarNazwa(string $uszkodzenie_rozmiar_nazwa) Return the first DamagesReportsTotal filtered by the uszkodzenie_rozmiar_nazwa column
 * @method DamagesReportsTotal findOneByKosztorysWartosc(string $kosztorys_wartosc) Return the first DamagesReportsTotal filtered by the kosztorys_wartosc column
 * @method DamagesReportsTotal findOneByKosztorysUpustFlaga(int $kosztorys_upust_flaga) Return the first DamagesReportsTotal filtered by the kosztorys_upust_flaga column
 * @method DamagesReportsTotal findOneByKosztorysUpustWartosc(string $kosztorys_upust_wartosc) Return the first DamagesReportsTotal filtered by the kosztorys_upust_wartosc column
 * @method DamagesReportsTotal findOneByKosztorysUpustProcent(string $kosztorys_upust_procent) Return the first DamagesReportsTotal filtered by the kosztorys_upust_procent column
 * @method DamagesReportsTotal findOneByKosztorysWartoscSamochodu(string $kosztorys_wartosc_samochodu) Return the first DamagesReportsTotal filtered by the kosztorys_wartosc_samochodu column
 * @method DamagesReportsTotal findOneByKosztorysWartoscOdliczenie(string $kosztorys_wartosc_odliczenia) Return the first DamagesReportsTotal filtered by the kosztorys_wartosc_odliczenia column
 * @method DamagesReportsTotal findOneByKosztorysDataDodania(string $kosztorys_data_dodania) Return the first DamagesReportsTotal filtered by the kosztorys_data_dodania column
 * @method DamagesReportsTotal findOneByTypNazwa(string $typ_nazwa) Return the first DamagesReportsTotal filtered by the typ_nazwa column
 * @method DamagesReportsTotal findOneByTypTransportu(string $typ_transportu) Return the first DamagesReportsTotal filtered by the typ_transportu column
 * @method DamagesReportsTotal findOneByFakturaId(int $faktura_id) Return the first DamagesReportsTotal filtered by the faktura_id column
 * @method DamagesReportsTotal findOneByFakturaWartoscSuma(string $faktura_wartosc_suma) Return the first DamagesReportsTotal filtered by the faktura_wartosc_suma column
 * @method DamagesReportsTotal findOneByFakturaDataDodania(string $faktura_data_dodania) Return the first DamagesReportsTotal filtered by the faktura_data_dodania column
 * @method DamagesReportsTotal findOneByNotaZaSzkodeWartoscSuma(string $nota_za_szkode_wartosc_suma) Return the first DamagesReportsTotal filtered by the nota_za_szkode_wartosc_suma column
 * @method DamagesReportsTotal findOneByNotaZaSzkodeDataDodania(string $nota_za_szkode_data_dodania) Return the first DamagesReportsTotal filtered by the nota_za_szkode_data_dodania column
 * @method DamagesReportsTotal findOneByNotaZaUtrateWartosciWartoscSuma(string $nota_za_utrate_wartosci_wartosc_suma) Return the first DamagesReportsTotal filtered by the nota_za_utrate_wartosci_wartosc_suma column
 * @method DamagesReportsTotal findOneByNotaZaUtrateWartosciDataDodania(string $nota_za_utrate_wartosci_data_dodania) Return the first DamagesReportsTotal filtered by the nota_za_utrate_wartosci_data_dodania column
 * @method DamagesReportsTotal findOneByProwadzacyImie(string $prowadzacy_imie) Return the first DamagesReportsTotal filtered by the prowadzacy_imie column
 * @method DamagesReportsTotal findOneByProwadzacyNazwisko(string $prowadzacy_nazwisko) Return the first DamagesReportsTotal filtered by the prowadzacy_nazwisko column
 * @method DamagesReportsTotal findOneByOpisUszkodzenia(string $opis_uszkodzenia) Return the first DamagesReportsTotal filtered by the opis_uszkodzenia column
 * @method DamagesReportsTotal findOneByUwagi(string $uwagi) Return the first DamagesReportsTotal filtered by the uwagi column
 *
 * @method array findBySzkodaId(int $szkoda_id) Return DamagesReportsTotal objects filtered by the szkoda_id column
 * @method array findByDataZgloszeniaSzkody(string $data_zgloszenia_szkody) Return DamagesReportsTotal objects filtered by the data_zgloszenia_szkody column
 * @method array findByDataUszkodzenia(string $data_uszkodzenia) Return DamagesReportsTotal objects filtered by the data_uszkodzenia column
 * @method array findByDataZgloszeniaDealera(string $data_zgloszenia_dealera) Return DamagesReportsTotal objects filtered by the data_zgloszenia_dealera column
 * @method array findBySamochodId(int $samochod_id) Return DamagesReportsTotal objects filtered by the samochod_id column
 * @method array findBySamochodVin(string $samochod_vin) Return DamagesReportsTotal objects filtered by the samochod_vin column
 * @method array findBySamochodNazwa(string $samochod_nazwa) Return DamagesReportsTotal objects filtered by the samochod_nazwa column
 * @method array findBySamochodNrKomisji(string $samochod_nr_komisji) Return DamagesReportsTotal objects filtered by the samochod_nr_komisji column
 * @method array findByStatusNazwa(string $status_nazwa) Return DamagesReportsTotal objects filtered by the status_nazwa column
 * @method array findByMarkaKod(string $marka_kod) Return DamagesReportsTotal objects filtered by the marka_kod column
 * @method array findByMarkaNazwa(string $marka_nazwa) Return DamagesReportsTotal objects filtered by the marka_nazwa column
 * @method array findByDealerNumer(string $dealer_numer) Return DamagesReportsTotal objects filtered by the dealer_numer column
 * @method array findByDealerMiasto(string $dealer_miasto) Return DamagesReportsTotal objects filtered by the dealer_miasto column
 * @method array findByUszkodzenieRodzajKod(string $uszkodzenie_rodzaj_kod) Return DamagesReportsTotal objects filtered by the uszkodzenie_rodzaj_kod column
 * @method array findByUszkodzenieRodzajNazwa(string $uszkodzenie_rodzaj_nazwa) Return DamagesReportsTotal objects filtered by the uszkodzenie_rodzaj_nazwa column
 * @method array findByUszkodzenieMiejsceKod(string $uszkodzenie_miejsce_kod) Return DamagesReportsTotal objects filtered by the uszkodzenie_miejsce_kod column
 * @method array findByUszkodzenieMiejsceNazwa(string $uszkodzenie_miejsce_nazwa) Return DamagesReportsTotal objects filtered by the uszkodzenie_miejsce_nazwa column
 * @method array findByUszkodzenieRozmiarKod(string $uszkodzenie_rozmiar_kod) Return DamagesReportsTotal objects filtered by the uszkodzenie_rozmiar_kod column
 * @method array findByUszkodzenieRozmiarNazwa(string $uszkodzenie_rozmiar_nazwa) Return DamagesReportsTotal objects filtered by the uszkodzenie_rozmiar_nazwa column
 * @method array findByKosztorysWartosc(string $kosztorys_wartosc) Return DamagesReportsTotal objects filtered by the kosztorys_wartosc column
 * @method array findByKosztorysUpustFlaga(int $kosztorys_upust_flaga) Return DamagesReportsTotal objects filtered by the kosztorys_upust_flaga column
 * @method array findByKosztorysUpustWartosc(string $kosztorys_upust_wartosc) Return DamagesReportsTotal objects filtered by the kosztorys_upust_wartosc column
 * @method array findByKosztorysUpustProcent(string $kosztorys_upust_procent) Return DamagesReportsTotal objects filtered by the kosztorys_upust_procent column
 * @method array findByKosztorysWartoscSamochodu(string $kosztorys_wartosc_samochodu) Return DamagesReportsTotal objects filtered by the kosztorys_wartosc_samochodu column
 * @method array findByKosztorysWartoscOdliczenie(string $kosztorys_wartosc_odliczenia) Return DamagesReportsTotal objects filtered by the kosztorys_wartosc_odliczenia column
 * @method array findByKosztorysDataDodania(string $kosztorys_data_dodania) Return DamagesReportsTotal objects filtered by the kosztorys_data_dodania column
 * @method array findByTypNazwa(string $typ_nazwa) Return DamagesReportsTotal objects filtered by the typ_nazwa column
 * @method array findByTypTransportu(string $typ_transportu) Return DamagesReportsTotal objects filtered by the typ_transportu column
 * @method array findByFakturaId(int $faktura_id) Return DamagesReportsTotal objects filtered by the faktura_id column
 * @method array findByFakturaWartoscSuma(string $faktura_wartosc_suma) Return DamagesReportsTotal objects filtered by the faktura_wartosc_suma column
 * @method array findByFakturaDataDodania(string $faktura_data_dodania) Return DamagesReportsTotal objects filtered by the faktura_data_dodania column
 * @method array findByNotaZaSzkodeWartoscSuma(string $nota_za_szkode_wartosc_suma) Return DamagesReportsTotal objects filtered by the nota_za_szkode_wartosc_suma column
 * @method array findByNotaZaSzkodeDataDodania(string $nota_za_szkode_data_dodania) Return DamagesReportsTotal objects filtered by the nota_za_szkode_data_dodania column
 * @method array findByNotaZaUtrateWartosciWartoscSuma(string $nota_za_utrate_wartosci_wartosc_suma) Return DamagesReportsTotal objects filtered by the nota_za_utrate_wartosci_wartosc_suma column
 * @method array findByNotaZaUtrateWartosciDataDodania(string $nota_za_utrate_wartosci_data_dodania) Return DamagesReportsTotal objects filtered by the nota_za_utrate_wartosci_data_dodania column
 * @method array findByProwadzacyImie(string $prowadzacy_imie) Return DamagesReportsTotal objects filtered by the prowadzacy_imie column
 * @method array findByProwadzacyNazwisko(string $prowadzacy_nazwisko) Return DamagesReportsTotal objects filtered by the prowadzacy_nazwisko column
 * @method array findByOpisUszkodzenia(string $opis_uszkodzenia) Return DamagesReportsTotal objects filtered by the opis_uszkodzenia column
 * @method array findByUwagi(string $uwagi) Return DamagesReportsTotal objects filtered by the uwagi column
 *
 * @package    propel.generator.damages.om
 */
abstract class DamagesBaseReportsTotalQuery extends ModelCriteria
{
    /**
     * Initializes internal state of DamagesBaseReportsTotalQuery object.
     *
     * @param     string $dbName The dabase name
     * @param     string $modelName The phpName of a model, e.g. 'Book'
     * @param     string $modelAlias The alias for the model in this query, e.g. 'b'
     */
    public function __construct($dbName = 'vgp_damages', $modelName = 'DamagesReportsTotal', $modelAlias = null)
    {
        parent::__construct($dbName, $modelName, $modelAlias);
    }

    /**
     * Returns a new DamagesReportsTotalQuery object.
     *
     * @param     string $modelAlias The alias of a model in the query
     * @param     DamagesReportsTotalQuery|Criteria $criteria Optional Criteria to build the query from
     *
     * @return DamagesReportsTotalQuery
     */
    public static function create($modelAlias = null, $criteria = null)
    {
        if ($criteria instanceof DamagesReportsTotalQuery) {
            return $criteria;
        }
        $query = new DamagesReportsTotalQuery();
        if (null !== $modelAlias) {
            $query->setModelAlias($modelAlias);
        }
        if ($criteria instanceof Criteria) {
            $query->mergeWith($criteria);
        }

        return $query;
    }

    /**
     * Find object by primary key.
     * Propel uses the instance pool to skip the database if the object exists.
     * Go fast if the query is untouched.
     *
     * <code>
     * $obj  = $c->findPk(12, $con);
     * </code>
     *
     * @param mixed $key Primary key to use for the query
     * @param     PropelPDO $con an optional connection object
     *
     * @return   DamagesReportsTotal|DamagesReportsTotal[]|mixed the result, formatted by the current formatter
     */
    public function findPk($key, $con = null)
    {
        if ($key === null) {
            return null;
        }
        if ((null !== ($obj = DamagesReportsTotalPeer::getInstanceFromPool((string) $key))) && !$this->formatter) {
            // the object is alredy in the instance pool
            return $obj;
        }
        if ($con === null) {
            $con = Propel::getConnection(DamagesReportsTotalPeer::DATABASE_NAME, Propel::CONNECTION_READ);
        }
        $this->basePreSelect($con);
        if ($this->formatter || $this->modelAlias || $this->with || $this->select
         || $this->selectColumns || $this->asColumns || $this->selectModifiers
         || $this->map || $this->having || $this->joins) {
            return $this->findPkComplex($key, $con);
        } else {
            return $this->findPkSimple($key, $con);
        }
    }

    /**
     * Find object by primary key using raw SQL to go fast.
     * Bypass doSelect() and the object formatter by using generated code.
     *
     * @param     mixed $key Primary key to use for the query
     * @param     PropelPDO $con A connection object
     *
     * @return   DamagesReportsTotal A model object, or null if the key is not found
     * @throws   PropelException
     */
    protected function findPkSimple($key, $con)
    {
        $sql = 'SELECT SZKODA_ID, DATA_ZGLOSZENIA_SZKODY, DATA_USZKODZENIA, DATA_ZGLOSZENIA_DEALERA, SAMOCHOD_ID, SAMOCHOD_VIN, SAMOCHOD_NAZWA, SAMOCHOD_NR_KOMISJI, STATUS_NAZWA, MARKA_KOD, MARKA_NAZWA, DEALER_NUMER, DEALER_MIASTO, USZKODZENIE_RODZAJ_KOD, USZKODZENIE_RODZAJ_NAZWA, USZKODZENIE_MIEJSCE_KOD, USZKODZENIE_MIEJSCE_NAZWA, USZKODZENIE_ROZMIAR_KOD, USZKODZENIE_ROZMIAR_NAZWA, KOSZTORYS_WARTOSC, KOSZTORYS_UPUST_FLAGA, KOSZTORYS_UPUST_WARTOSC, KOSZTORYS_UPUST_PROCENT, KOSZTORYS_WARTOSC_SAMOCHODU, KOSZTORYS_WARTOSC_ODLICZENIA, KOSZTORYS_DATA_DODANIA, TYP_NAZWA, TYP_TRANSPORTU, FAKTURA_ID, FAKTURA_WARTOSC_SUMA, FAKTURA_DATA_DODANIA, NOTA_ZA_SZKODE_WARTOSC_SUMA, NOTA_ZA_SZKODE_DATA_DODANIA, NOTA_ZA_UTRATE_WARTOSCI_WARTOSC_SUMA, NOTA_ZA_UTRATE_WARTOSCI_DATA_DODANIA, PROWADZACY_IMIE, PROWADZACY_NAZWISKO, OPIS_USZKODZENIA, UWAGI FROM reports_total WHERE SZKODA_ID = :p0';
        try {
            $stmt = $con->prepare($sql);
            $stmt->bindValue(':p0', $key, PDO::PARAM_INT);
            $stmt->execute();
        } catch (Exception $e) {
            Propel::log($e->getMessage(), Propel::LOG_ERR);
            throw new PropelException(sprintf('Unable to execute SELECT statement [%s]', $sql), $e);
        }
        $obj = null;
        if ($row = $stmt->fetch(PDO::FETCH_NUM)) {
            $obj = new DamagesReportsTotal();
            $obj->hydrate($row);
            DamagesReportsTotalPeer::addInstanceToPool($obj, (string) $key);
        }
        $stmt->closeCursor();

        return $obj;
    }

    /**
     * Find object by primary key.
     *
     * @param     mixed $key Primary key to use for the query
     * @param     PropelPDO $con A connection object
     *
     * @return DamagesReportsTotal|DamagesReportsTotal[]|mixed the result, formatted by the current formatter
     */
    protected function findPkComplex($key, $con)
    {
        // As the query uses a PK condition, no limit(1) is necessary.
        $criteria = $this->isKeepQuery() ? clone $this : $this;
        $stmt = $criteria
            ->filterByPrimaryKey($key)
            ->doSelect($con);

        return $criteria->getFormatter()->init($criteria)->formatOne($stmt);
    }

    /**
     * Find objects by primary key
     * <code>
     * $objs = $c->findPks(array(12, 56, 832), $con);
     * </code>
     * @param     array $keys Primary keys to use for the query
     * @param     PropelPDO $con an optional connection object
     *
     * @return PropelObjectCollection|DamagesReportsTotal[]|mixed the list of results, formatted by the current formatter
     */
    public function findPks($keys, $con = null)
    {
        if ($con === null) {
            $con = Propel::getConnection($this->getDbName(), Propel::CONNECTION_READ);
        }
        $this->basePreSelect($con);
        $criteria = $this->isKeepQuery() ? clone $this : $this;
        $stmt = $criteria
            ->filterByPrimaryKeys($keys)
            ->doSelect($con);

        return $criteria->getFormatter()->init($criteria)->format($stmt);
    }

    /**
     * Filter the query by primary key
     *
     * @param     mixed $key Primary key to use for the query
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByPrimaryKey($key)
    {

        return $this->addUsingAlias(DamagesReportsTotalPeer::SZKODA_ID, $key, Criteria::EQUAL);
    }

    /**
     * Filter the query by a list of primary keys
     *
     * @param     array $keys The list of primary key to use for the query
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByPrimaryKeys($keys)
    {

        return $this->addUsingAlias(DamagesReportsTotalPeer::SZKODA_ID, $keys, Criteria::IN);
    }

    /**
     * Filter the query on the szkoda_id column
     *
     * Example usage:
     * <code>
     * $query->filterBySzkodaId(1234); // WHERE szkoda_id = 1234
     * $query->filterBySzkodaId(array(12, 34)); // WHERE szkoda_id IN (12, 34)
     * $query->filterBySzkodaId(array('min' => 12)); // WHERE szkoda_id > 12
     * </code>
     *
     * @param     mixed $szkodaId The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterBySzkodaId($szkodaId = null, $comparison = null)
    {
        if (is_array($szkodaId) && null === $comparison) {
            $comparison = Criteria::IN;
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::SZKODA_ID, $szkodaId, $comparison);
    }

    /**
     * Filter the query on the data_zgloszenia_szkody column
     *
     * Example usage:
     * <code>
     * $query->filterByDataZgloszeniaSzkody('2011-03-14'); // WHERE data_zgloszenia_szkody = '2011-03-14'
     * $query->filterByDataZgloszeniaSzkody('now'); // WHERE data_zgloszenia_szkody = '2011-03-14'
     * $query->filterByDataZgloszeniaSzkody(array('max' => 'yesterday')); // WHERE data_zgloszenia_szkody > '2011-03-13'
     * </code>
     *
     * @param     mixed $dataZgloszeniaSzkody The value to use as filter.
     *              Values can be integers (unix timestamps), DateTime objects, or strings.
     *              Empty strings are treated as NULL.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByDataZgloszeniaSzkody($dataZgloszeniaSzkody = null, $comparison = null)
    {
        if (is_array($dataZgloszeniaSzkody)) {
            $useMinMax = false;
            if (isset($dataZgloszeniaSzkody['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::DATA_ZGLOSZENIA_SZKODY, $dataZgloszeniaSzkody['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($dataZgloszeniaSzkody['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::DATA_ZGLOSZENIA_SZKODY, $dataZgloszeniaSzkody['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::DATA_ZGLOSZENIA_SZKODY, $dataZgloszeniaSzkody, $comparison);
    }

    /**
     * Filter the query on the data_uszkodzenia column
     *
     * Example usage:
     * <code>
     * $query->filterByDataUszkodzenia('2011-03-14'); // WHERE data_uszkodzenia = '2011-03-14'
     * $query->filterByDataUszkodzenia('now'); // WHERE data_uszkodzenia = '2011-03-14'
     * $query->filterByDataUszkodzenia(array('max' => 'yesterday')); // WHERE data_uszkodzenia > '2011-03-13'
     * </code>
     *
     * @param     mixed $dataUszkodzenia The value to use as filter.
     *              Values can be integers (unix timestamps), DateTime objects, or strings.
     *              Empty strings are treated as NULL.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByDataUszkodzenia($dataUszkodzenia = null, $comparison = null)
    {
        if (is_array($dataUszkodzenia)) {
            $useMinMax = false;
            if (isset($dataUszkodzenia['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::DATA_USZKODZENIA, $dataUszkodzenia['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($dataUszkodzenia['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::DATA_USZKODZENIA, $dataUszkodzenia['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::DATA_USZKODZENIA, $dataUszkodzenia, $comparison);
    }

    /**
     * Filter the query on the data_zgloszenia_dealera column
     *
     * Example usage:
     * <code>
     * $query->filterByDataZgloszeniaDealera('2011-03-14'); // WHERE data_zgloszenia_dealera = '2011-03-14'
     * $query->filterByDataZgloszeniaDealera('now'); // WHERE data_zgloszenia_dealera = '2011-03-14'
     * $query->filterByDataZgloszeniaDealera(array('max' => 'yesterday')); // WHERE data_zgloszenia_dealera > '2011-03-13'
     * </code>
     *
     * @param     mixed $dataZgloszeniaDealera The value to use as filter.
     *              Values can be integers (unix timestamps), DateTime objects, or strings.
     *              Empty strings are treated as NULL.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByDataZgloszeniaDealera($dataZgloszeniaDealera = null, $comparison = null)
    {
        if (is_array($dataZgloszeniaDealera)) {
            $useMinMax = false;
            if (isset($dataZgloszeniaDealera['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::DATA_ZGLOSZENIA_DEALERA, $dataZgloszeniaDealera['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($dataZgloszeniaDealera['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::DATA_ZGLOSZENIA_DEALERA, $dataZgloszeniaDealera['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::DATA_ZGLOSZENIA_DEALERA, $dataZgloszeniaDealera, $comparison);
    }

    /**
     * Filter the query on the samochod_id column
     *
     * Example usage:
     * <code>
     * $query->filterBySamochodId(1234); // WHERE samochod_id = 1234
     * $query->filterBySamochodId(array(12, 34)); // WHERE samochod_id IN (12, 34)
     * $query->filterBySamochodId(array('min' => 12)); // WHERE samochod_id > 12
     * </code>
     *
     * @param     mixed $samochodId The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterBySamochodId($samochodId = null, $comparison = null)
    {
        if (is_array($samochodId)) {
            $useMinMax = false;
            if (isset($samochodId['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::SAMOCHOD_ID, $samochodId['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($samochodId['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::SAMOCHOD_ID, $samochodId['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::SAMOCHOD_ID, $samochodId, $comparison);
    }

    /**
     * Filter the query on the samochod_vin column
     *
     * Example usage:
     * <code>
     * $query->filterBySamochodVin('fooValue');   // WHERE samochod_vin = 'fooValue'
     * $query->filterBySamochodVin('%fooValue%'); // WHERE samochod_vin LIKE '%fooValue%'
     * </code>
     *
     * @param     string $samochodVin The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterBySamochodVin($samochodVin = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($samochodVin)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $samochodVin)) {
                $samochodVin = str_replace('*', '%', $samochodVin);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::SAMOCHOD_VIN, $samochodVin, $comparison);
    }

    /**
     * Filter the query on the samochod_nazwa column
     *
     * Example usage:
     * <code>
     * $query->filterBySamochodNazwa('fooValue');   // WHERE samochod_nazwa = 'fooValue'
     * $query->filterBySamochodNazwa('%fooValue%'); // WHERE samochod_nazwa LIKE '%fooValue%'
     * </code>
     *
     * @param     string $samochodNazwa The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterBySamochodNazwa($samochodNazwa = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($samochodNazwa)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $samochodNazwa)) {
                $samochodNazwa = str_replace('*', '%', $samochodNazwa);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::SAMOCHOD_NAZWA, $samochodNazwa, $comparison);
    }

    /**
     * Filter the query on the samochod_nr_komisji column
     *
     * Example usage:
     * <code>
     * $query->filterBySamochodNrKomisji('fooValue');   // WHERE samochod_nr_komisji = 'fooValue'
     * $query->filterBySamochodNrKomisji('%fooValue%'); // WHERE samochod_nr_komisji LIKE '%fooValue%'
     * </code>
     *
     * @param     string $samochodNrKomisji The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterBySamochodNrKomisji($samochodNrKomisji = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($samochodNrKomisji)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $samochodNrKomisji)) {
                $samochodNrKomisji = str_replace('*', '%', $samochodNrKomisji);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::SAMOCHOD_NR_KOMISJI, $samochodNrKomisji, $comparison);
    }

    /**
     * Filter the query on the status_nazwa column
     *
     * Example usage:
     * <code>
     * $query->filterByStatusNazwa('fooValue');   // WHERE status_nazwa = 'fooValue'
     * $query->filterByStatusNazwa('%fooValue%'); // WHERE status_nazwa LIKE '%fooValue%'
     * </code>
     *
     * @param     string $statusNazwa The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByStatusNazwa($statusNazwa = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($statusNazwa)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $statusNazwa)) {
                $statusNazwa = str_replace('*', '%', $statusNazwa);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::STATUS_NAZWA, $statusNazwa, $comparison);
    }

    /**
     * Filter the query on the marka_kod column
     *
     * Example usage:
     * <code>
     * $query->filterByMarkaKod('fooValue');   // WHERE marka_kod = 'fooValue'
     * $query->filterByMarkaKod('%fooValue%'); // WHERE marka_kod LIKE '%fooValue%'
     * </code>
     *
     * @param     string $markaKod The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByMarkaKod($markaKod = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($markaKod)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $markaKod)) {
                $markaKod = str_replace('*', '%', $markaKod);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::MARKA_KOD, $markaKod, $comparison);
    }

    /**
     * Filter the query on the marka_nazwa column
     *
     * Example usage:
     * <code>
     * $query->filterByMarkaNazwa('fooValue');   // WHERE marka_nazwa = 'fooValue'
     * $query->filterByMarkaNazwa('%fooValue%'); // WHERE marka_nazwa LIKE '%fooValue%'
     * </code>
     *
     * @param     string $markaNazwa The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByMarkaNazwa($markaNazwa = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($markaNazwa)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $markaNazwa)) {
                $markaNazwa = str_replace('*', '%', $markaNazwa);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::MARKA_NAZWA, $markaNazwa, $comparison);
    }

    /**
     * Filter the query on the dealer_numer column
     *
     * Example usage:
     * <code>
     * $query->filterByDealerNumer('fooValue');   // WHERE dealer_numer = 'fooValue'
     * $query->filterByDealerNumer('%fooValue%'); // WHERE dealer_numer LIKE '%fooValue%'
     * </code>
     *
     * @param     string $dealerNumer The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByDealerNumer($dealerNumer = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($dealerNumer)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $dealerNumer)) {
                $dealerNumer = str_replace('*', '%', $dealerNumer);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::DEALER_NUMER, $dealerNumer, $comparison);
    }

    /**
     * Filter the query on the dealer_miasto column
     *
     * Example usage:
     * <code>
     * $query->filterByDealerMiasto('fooValue');   // WHERE dealer_miasto = 'fooValue'
     * $query->filterByDealerMiasto('%fooValue%'); // WHERE dealer_miasto LIKE '%fooValue%'
     * </code>
     *
     * @param     string $dealerMiasto The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByDealerMiasto($dealerMiasto = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($dealerMiasto)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $dealerMiasto)) {
                $dealerMiasto = str_replace('*', '%', $dealerMiasto);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::DEALER_MIASTO, $dealerMiasto, $comparison);
    }

    /**
     * Filter the query on the uszkodzenie_rodzaj_kod column
     *
     * Example usage:
     * <code>
     * $query->filterByUszkodzenieRodzajKod('fooValue');   // WHERE uszkodzenie_rodzaj_kod = 'fooValue'
     * $query->filterByUszkodzenieRodzajKod('%fooValue%'); // WHERE uszkodzenie_rodzaj_kod LIKE '%fooValue%'
     * </code>
     *
     * @param     string $uszkodzenieRodzajKod The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByUszkodzenieRodzajKod($uszkodzenieRodzajKod = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($uszkodzenieRodzajKod)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $uszkodzenieRodzajKod)) {
                $uszkodzenieRodzajKod = str_replace('*', '%', $uszkodzenieRodzajKod);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::USZKODZENIE_RODZAJ_KOD, $uszkodzenieRodzajKod, $comparison);
    }

    /**
     * Filter the query on the uszkodzenie_rodzaj_nazwa column
     *
     * Example usage:
     * <code>
     * $query->filterByUszkodzenieRodzajNazwa('fooValue');   // WHERE uszkodzenie_rodzaj_nazwa = 'fooValue'
     * $query->filterByUszkodzenieRodzajNazwa('%fooValue%'); // WHERE uszkodzenie_rodzaj_nazwa LIKE '%fooValue%'
     * </code>
     *
     * @param     string $uszkodzenieRodzajNazwa The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByUszkodzenieRodzajNazwa($uszkodzenieRodzajNazwa = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($uszkodzenieRodzajNazwa)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $uszkodzenieRodzajNazwa)) {
                $uszkodzenieRodzajNazwa = str_replace('*', '%', $uszkodzenieRodzajNazwa);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::USZKODZENIE_RODZAJ_NAZWA, $uszkodzenieRodzajNazwa, $comparison);
    }

    /**
     * Filter the query on the uszkodzenie_miejsce_kod column
     *
     * Example usage:
     * <code>
     * $query->filterByUszkodzenieMiejsceKod('fooValue');   // WHERE uszkodzenie_miejsce_kod = 'fooValue'
     * $query->filterByUszkodzenieMiejsceKod('%fooValue%'); // WHERE uszkodzenie_miejsce_kod LIKE '%fooValue%'
     * </code>
     *
     * @param     string $uszkodzenieMiejsceKod The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByUszkodzenieMiejsceKod($uszkodzenieMiejsceKod = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($uszkodzenieMiejsceKod)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $uszkodzenieMiejsceKod)) {
                $uszkodzenieMiejsceKod = str_replace('*', '%', $uszkodzenieMiejsceKod);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::USZKODZENIE_MIEJSCE_KOD, $uszkodzenieMiejsceKod, $comparison);
    }

    /**
     * Filter the query on the uszkodzenie_miejsce_nazwa column
     *
     * Example usage:
     * <code>
     * $query->filterByUszkodzenieMiejsceNazwa('fooValue');   // WHERE uszkodzenie_miejsce_nazwa = 'fooValue'
     * $query->filterByUszkodzenieMiejsceNazwa('%fooValue%'); // WHERE uszkodzenie_miejsce_nazwa LIKE '%fooValue%'
     * </code>
     *
     * @param     string $uszkodzenieMiejsceNazwa The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByUszkodzenieMiejsceNazwa($uszkodzenieMiejsceNazwa = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($uszkodzenieMiejsceNazwa)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $uszkodzenieMiejsceNazwa)) {
                $uszkodzenieMiejsceNazwa = str_replace('*', '%', $uszkodzenieMiejsceNazwa);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::USZKODZENIE_MIEJSCE_NAZWA, $uszkodzenieMiejsceNazwa, $comparison);
    }

    /**
     * Filter the query on the uszkodzenie_rozmiar_kod column
     *
     * Example usage:
     * <code>
     * $query->filterByUszkodzenieRozmiarKod('fooValue');   // WHERE uszkodzenie_rozmiar_kod = 'fooValue'
     * $query->filterByUszkodzenieRozmiarKod('%fooValue%'); // WHERE uszkodzenie_rozmiar_kod LIKE '%fooValue%'
     * </code>
     *
     * @param     string $uszkodzenieRozmiarKod The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByUszkodzenieRozmiarKod($uszkodzenieRozmiarKod = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($uszkodzenieRozmiarKod)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $uszkodzenieRozmiarKod)) {
                $uszkodzenieRozmiarKod = str_replace('*', '%', $uszkodzenieRozmiarKod);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::USZKODZENIE_ROZMIAR_KOD, $uszkodzenieRozmiarKod, $comparison);
    }

    /**
     * Filter the query on the uszkodzenie_rozmiar_nazwa column
     *
     * Example usage:
     * <code>
     * $query->filterByUszkodzenieRozmiarNazwa('fooValue');   // WHERE uszkodzenie_rozmiar_nazwa = 'fooValue'
     * $query->filterByUszkodzenieRozmiarNazwa('%fooValue%'); // WHERE uszkodzenie_rozmiar_nazwa LIKE '%fooValue%'
     * </code>
     *
     * @param     string $uszkodzenieRozmiarNazwa The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByUszkodzenieRozmiarNazwa($uszkodzenieRozmiarNazwa = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($uszkodzenieRozmiarNazwa)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $uszkodzenieRozmiarNazwa)) {
                $uszkodzenieRozmiarNazwa = str_replace('*', '%', $uszkodzenieRozmiarNazwa);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::USZKODZENIE_ROZMIAR_NAZWA, $uszkodzenieRozmiarNazwa, $comparison);
    }

    /**
     * Filter the query on the kosztorys_wartosc column
     *
     * Example usage:
     * <code>
     * $query->filterByKosztorysWartosc(1234); // WHERE kosztorys_wartosc = 1234
     * $query->filterByKosztorysWartosc(array(12, 34)); // WHERE kosztorys_wartosc IN (12, 34)
     * $query->filterByKosztorysWartosc(array('min' => 12)); // WHERE kosztorys_wartosc > 12
     * </code>
     *
     * @param     mixed $kosztorysWartosc The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByKosztorysWartosc($kosztorysWartosc = null, $comparison = null)
    {
        if (is_array($kosztorysWartosc)) {
            $useMinMax = false;
            if (isset($kosztorysWartosc['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_WARTOSC, $kosztorysWartosc['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($kosztorysWartosc['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_WARTOSC, $kosztorysWartosc['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_WARTOSC, $kosztorysWartosc, $comparison);
    }

    /**
     * Filter the query on the kosztorys_upust_flaga column
     *
     * Example usage:
     * <code>
     * $query->filterByKosztorysUpustFlaga(1234); // WHERE kosztorys_upust_flaga = 1234
     * $query->filterByKosztorysUpustFlaga(array(12, 34)); // WHERE kosztorys_upust_flaga IN (12, 34)
     * $query->filterByKosztorysUpustFlaga(array('min' => 12)); // WHERE kosztorys_upust_flaga > 12
     * </code>
     *
     * @param     mixed $kosztorysUpustFlaga The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByKosztorysUpustFlaga($kosztorysUpustFlaga = null, $comparison = null)
    {
        if (is_array($kosztorysUpustFlaga)) {
            $useMinMax = false;
            if (isset($kosztorysUpustFlaga['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_UPUST_FLAGA, $kosztorysUpustFlaga['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($kosztorysUpustFlaga['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_UPUST_FLAGA, $kosztorysUpustFlaga['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_UPUST_FLAGA, $kosztorysUpustFlaga, $comparison);
    }

    /**
     * Filter the query on the kosztorys_upust_wartosc column
     *
     * Example usage:
     * <code>
     * $query->filterByKosztorysUpustWartosc(1234); // WHERE kosztorys_upust_wartosc = 1234
     * $query->filterByKosztorysUpustWartosc(array(12, 34)); // WHERE kosztorys_upust_wartosc IN (12, 34)
     * $query->filterByKosztorysUpustWartosc(array('min' => 12)); // WHERE kosztorys_upust_wartosc > 12
     * </code>
     *
     * @param     mixed $kosztorysUpustWartosc The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByKosztorysUpustWartosc($kosztorysUpustWartosc = null, $comparison = null)
    {
        if (is_array($kosztorysUpustWartosc)) {
            $useMinMax = false;
            if (isset($kosztorysUpustWartosc['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_UPUST_WARTOSC, $kosztorysUpustWartosc['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($kosztorysUpustWartosc['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_UPUST_WARTOSC, $kosztorysUpustWartosc['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_UPUST_WARTOSC, $kosztorysUpustWartosc, $comparison);
    }

    /**
     * Filter the query on the kosztorys_upust_procent column
     *
     * Example usage:
     * <code>
     * $query->filterByKosztorysUpustProcent(1234); // WHERE kosztorys_upust_procent = 1234
     * $query->filterByKosztorysUpustProcent(array(12, 34)); // WHERE kosztorys_upust_procent IN (12, 34)
     * $query->filterByKosztorysUpustProcent(array('min' => 12)); // WHERE kosztorys_upust_procent > 12
     * </code>
     *
     * @param     mixed $kosztorysUpustProcent The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByKosztorysUpustProcent($kosztorysUpustProcent = null, $comparison = null)
    {
        if (is_array($kosztorysUpustProcent)) {
            $useMinMax = false;
            if (isset($kosztorysUpustProcent['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_UPUST_PROCENT, $kosztorysUpustProcent['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($kosztorysUpustProcent['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_UPUST_PROCENT, $kosztorysUpustProcent['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_UPUST_PROCENT, $kosztorysUpustProcent, $comparison);
    }

    /**
     * Filter the query on the kosztorys_wartosc_samochodu column
     *
     * Example usage:
     * <code>
     * $query->filterByKosztorysWartoscSamochodu(1234); // WHERE kosztorys_wartosc_samochodu = 1234
     * $query->filterByKosztorysWartoscSamochodu(array(12, 34)); // WHERE kosztorys_wartosc_samochodu IN (12, 34)
     * $query->filterByKosztorysWartoscSamochodu(array('min' => 12)); // WHERE kosztorys_wartosc_samochodu > 12
     * </code>
     *
     * @param     mixed $kosztorysWartoscSamochodu The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByKosztorysWartoscSamochodu($kosztorysWartoscSamochodu = null, $comparison = null)
    {
        if (is_array($kosztorysWartoscSamochodu)) {
            $useMinMax = false;
            if (isset($kosztorysWartoscSamochodu['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_WARTOSC_SAMOCHODU, $kosztorysWartoscSamochodu['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($kosztorysWartoscSamochodu['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_WARTOSC_SAMOCHODU, $kosztorysWartoscSamochodu['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_WARTOSC_SAMOCHODU, $kosztorysWartoscSamochodu, $comparison);
    }

    /**
     * Filter the query on the kosztorys_wartosc_odliczenia column
     *
     * Example usage:
     * <code>
     * $query->filterByKosztorysWartoscOdliczenie(1234); // WHERE kosztorys_wartosc_odliczenia = 1234
     * $query->filterByKosztorysWartoscOdliczenie(array(12, 34)); // WHERE kosztorys_wartosc_odliczenia IN (12, 34)
     * $query->filterByKosztorysWartoscOdliczenie(array('min' => 12)); // WHERE kosztorys_wartosc_odliczenia > 12
     * </code>
     *
     * @param     mixed $kosztorysWartoscOdliczenie The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByKosztorysWartoscOdliczenie($kosztorysWartoscOdliczenie = null, $comparison = null)
    {
        if (is_array($kosztorysWartoscOdliczenie)) {
            $useMinMax = false;
            if (isset($kosztorysWartoscOdliczenie['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_WARTOSC_ODLICZENIA, $kosztorysWartoscOdliczenie['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($kosztorysWartoscOdliczenie['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_WARTOSC_ODLICZENIA, $kosztorysWartoscOdliczenie['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_WARTOSC_ODLICZENIA, $kosztorysWartoscOdliczenie, $comparison);
    }

    /**
     * Filter the query on the kosztorys_data_dodania column
     *
     * Example usage:
     * <code>
     * $query->filterByKosztorysDataDodania('2011-03-14'); // WHERE kosztorys_data_dodania = '2011-03-14'
     * $query->filterByKosztorysDataDodania('now'); // WHERE kosztorys_data_dodania = '2011-03-14'
     * $query->filterByKosztorysDataDodania(array('max' => 'yesterday')); // WHERE kosztorys_data_dodania > '2011-03-13'
     * </code>
     *
     * @param     mixed $kosztorysDataDodania The value to use as filter.
     *              Values can be integers (unix timestamps), DateTime objects, or strings.
     *              Empty strings are treated as NULL.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByKosztorysDataDodania($kosztorysDataDodania = null, $comparison = null)
    {
        if (is_array($kosztorysDataDodania)) {
            $useMinMax = false;
            if (isset($kosztorysDataDodania['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_DATA_DODANIA, $kosztorysDataDodania['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($kosztorysDataDodania['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_DATA_DODANIA, $kosztorysDataDodania['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::KOSZTORYS_DATA_DODANIA, $kosztorysDataDodania, $comparison);
    }

    /**
     * Filter the query on the typ_nazwa column
     *
     * Example usage:
     * <code>
     * $query->filterByTypNazwa('fooValue');   // WHERE typ_nazwa = 'fooValue'
     * $query->filterByTypNazwa('%fooValue%'); // WHERE typ_nazwa LIKE '%fooValue%'
     * </code>
     *
     * @param     string $typNazwa The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByTypNazwa($typNazwa = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($typNazwa)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $typNazwa)) {
                $typNazwa = str_replace('*', '%', $typNazwa);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::TYP_NAZWA, $typNazwa, $comparison);
    }

    /**
     * Filter the query on the typ_transportu column
     *
     * Example usage:
     * <code>
     * $query->filterByTypTransportu('fooValue');   // WHERE typ_transportu = 'fooValue'
     * $query->filterByTypTransportu('%fooValue%'); // WHERE typ_transportu LIKE '%fooValue%'
     * </code>
     *
     * @param     string $typTransportu The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByTypTransportu($typTransportu = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($typTransportu)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $typTransportu)) {
                $typTransportu = str_replace('*', '%', $typTransportu);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::TYP_TRANSPORTU, $typTransportu, $comparison);
    }

    /**
     * Filter the query on the faktura_id column
     *
     * Example usage:
     * <code>
     * $query->filterByFakturaId(1234); // WHERE faktura_id = 1234
     * $query->filterByFakturaId(array(12, 34)); // WHERE faktura_id IN (12, 34)
     * $query->filterByFakturaId(array('min' => 12)); // WHERE faktura_id > 12
     * </code>
     *
     * @param     mixed $fakturaId The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByFakturaId($fakturaId = null, $comparison = null)
    {
        if (is_array($fakturaId)) {
            $useMinMax = false;
            if (isset($fakturaId['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::FAKTURA_ID, $fakturaId['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($fakturaId['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::FAKTURA_ID, $fakturaId['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::FAKTURA_ID, $fakturaId, $comparison);
    }

    /**
     * Filter the query on the faktura_wartosc_suma column
     *
     * Example usage:
     * <code>
     * $query->filterByFakturaWartoscSuma(1234); // WHERE faktura_wartosc_suma = 1234
     * $query->filterByFakturaWartoscSuma(array(12, 34)); // WHERE faktura_wartosc_suma IN (12, 34)
     * $query->filterByFakturaWartoscSuma(array('min' => 12)); // WHERE faktura_wartosc_suma > 12
     * </code>
     *
     * @param     mixed $fakturaWartoscSuma The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByFakturaWartoscSuma($fakturaWartoscSuma = null, $comparison = null)
    {
        if (is_array($fakturaWartoscSuma)) {
            $useMinMax = false;
            if (isset($fakturaWartoscSuma['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::FAKTURA_WARTOSC_SUMA, $fakturaWartoscSuma['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($fakturaWartoscSuma['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::FAKTURA_WARTOSC_SUMA, $fakturaWartoscSuma['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::FAKTURA_WARTOSC_SUMA, $fakturaWartoscSuma, $comparison);
    }

    /**
     * Filter the query on the faktura_data_dodania column
     *
     * Example usage:
     * <code>
     * $query->filterByFakturaDataDodania('2011-03-14'); // WHERE faktura_data_dodania = '2011-03-14'
     * $query->filterByFakturaDataDodania('now'); // WHERE faktura_data_dodania = '2011-03-14'
     * $query->filterByFakturaDataDodania(array('max' => 'yesterday')); // WHERE faktura_data_dodania > '2011-03-13'
     * </code>
     *
     * @param     mixed $fakturaDataDodania The value to use as filter.
     *              Values can be integers (unix timestamps), DateTime objects, or strings.
     *              Empty strings are treated as NULL.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByFakturaDataDodania($fakturaDataDodania = null, $comparison = null)
    {
        if (is_array($fakturaDataDodania)) {
            $useMinMax = false;
            if (isset($fakturaDataDodania['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::FAKTURA_DATA_DODANIA, $fakturaDataDodania['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($fakturaDataDodania['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::FAKTURA_DATA_DODANIA, $fakturaDataDodania['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::FAKTURA_DATA_DODANIA, $fakturaDataDodania, $comparison);
    }

    /**
     * Filter the query on the nota_za_szkode_wartosc_suma column
     *
     * Example usage:
     * <code>
     * $query->filterByNotaZaSzkodeWartoscSuma(1234); // WHERE nota_za_szkode_wartosc_suma = 1234
     * $query->filterByNotaZaSzkodeWartoscSuma(array(12, 34)); // WHERE nota_za_szkode_wartosc_suma IN (12, 34)
     * $query->filterByNotaZaSzkodeWartoscSuma(array('min' => 12)); // WHERE nota_za_szkode_wartosc_suma > 12
     * </code>
     *
     * @param     mixed $notaZaSzkodeWartoscSuma The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByNotaZaSzkodeWartoscSuma($notaZaSzkodeWartoscSuma = null, $comparison = null)
    {
        if (is_array($notaZaSzkodeWartoscSuma)) {
            $useMinMax = false;
            if (isset($notaZaSzkodeWartoscSuma['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_SZKODE_WARTOSC_SUMA, $notaZaSzkodeWartoscSuma['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($notaZaSzkodeWartoscSuma['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_SZKODE_WARTOSC_SUMA, $notaZaSzkodeWartoscSuma['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_SZKODE_WARTOSC_SUMA, $notaZaSzkodeWartoscSuma, $comparison);
    }

    /**
     * Filter the query on the nota_za_szkode_data_dodania column
     *
     * Example usage:
     * <code>
     * $query->filterByNotaZaSzkodeDataDodania('2011-03-14'); // WHERE nota_za_szkode_data_dodania = '2011-03-14'
     * $query->filterByNotaZaSzkodeDataDodania('now'); // WHERE nota_za_szkode_data_dodania = '2011-03-14'
     * $query->filterByNotaZaSzkodeDataDodania(array('max' => 'yesterday')); // WHERE nota_za_szkode_data_dodania > '2011-03-13'
     * </code>
     *
     * @param     mixed $notaZaSzkodeDataDodania The value to use as filter.
     *              Values can be integers (unix timestamps), DateTime objects, or strings.
     *              Empty strings are treated as NULL.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByNotaZaSzkodeDataDodania($notaZaSzkodeDataDodania = null, $comparison = null)
    {
        if (is_array($notaZaSzkodeDataDodania)) {
            $useMinMax = false;
            if (isset($notaZaSzkodeDataDodania['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_SZKODE_DATA_DODANIA, $notaZaSzkodeDataDodania['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($notaZaSzkodeDataDodania['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_SZKODE_DATA_DODANIA, $notaZaSzkodeDataDodania['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_SZKODE_DATA_DODANIA, $notaZaSzkodeDataDodania, $comparison);
    }

    /**
     * Filter the query on the nota_za_utrate_wartosci_wartosc_suma column
     *
     * Example usage:
     * <code>
     * $query->filterByNotaZaUtrateWartosciWartoscSuma(1234); // WHERE nota_za_utrate_wartosci_wartosc_suma = 1234
     * $query->filterByNotaZaUtrateWartosciWartoscSuma(array(12, 34)); // WHERE nota_za_utrate_wartosci_wartosc_suma IN (12, 34)
     * $query->filterByNotaZaUtrateWartosciWartoscSuma(array('min' => 12)); // WHERE nota_za_utrate_wartosci_wartosc_suma > 12
     * </code>
     *
     * @param     mixed $notaZaUtrateWartosciWartoscSuma The value to use as filter.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByNotaZaUtrateWartosciWartoscSuma($notaZaUtrateWartosciWartoscSuma = null, $comparison = null)
    {
        if (is_array($notaZaUtrateWartosciWartoscSuma)) {
            $useMinMax = false;
            if (isset($notaZaUtrateWartosciWartoscSuma['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_UTRATE_WARTOSCI_WARTOSC_SUMA, $notaZaUtrateWartosciWartoscSuma['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($notaZaUtrateWartosciWartoscSuma['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_UTRATE_WARTOSCI_WARTOSC_SUMA, $notaZaUtrateWartosciWartoscSuma['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_UTRATE_WARTOSCI_WARTOSC_SUMA, $notaZaUtrateWartosciWartoscSuma, $comparison);
    }

    /**
     * Filter the query on the nota_za_utrate_wartosci_data_dodania column
     *
     * Example usage:
     * <code>
     * $query->filterByNotaZaUtrateWartosciDataDodania('2011-03-14'); // WHERE nota_za_utrate_wartosci_data_dodania = '2011-03-14'
     * $query->filterByNotaZaUtrateWartosciDataDodania('now'); // WHERE nota_za_utrate_wartosci_data_dodania = '2011-03-14'
     * $query->filterByNotaZaUtrateWartosciDataDodania(array('max' => 'yesterday')); // WHERE nota_za_utrate_wartosci_data_dodania > '2011-03-13'
     * </code>
     *
     * @param     mixed $notaZaUtrateWartosciDataDodania The value to use as filter.
     *              Values can be integers (unix timestamps), DateTime objects, or strings.
     *              Empty strings are treated as NULL.
     *              Use scalar values for equality.
     *              Use array values for in_array() equivalent.
     *              Use associative array('min' => $minValue, 'max' => $maxValue) for intervals.
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByNotaZaUtrateWartosciDataDodania($notaZaUtrateWartosciDataDodania = null, $comparison = null)
    {
        if (is_array($notaZaUtrateWartosciDataDodania)) {
            $useMinMax = false;
            if (isset($notaZaUtrateWartosciDataDodania['min'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_UTRATE_WARTOSCI_DATA_DODANIA, $notaZaUtrateWartosciDataDodania['min'], Criteria::GREATER_EQUAL);
                $useMinMax = true;
            }
            if (isset($notaZaUtrateWartosciDataDodania['max'])) {
                $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_UTRATE_WARTOSCI_DATA_DODANIA, $notaZaUtrateWartosciDataDodania['max'], Criteria::LESS_EQUAL);
                $useMinMax = true;
            }
            if ($useMinMax) {
                return $this;
            }
            if (null === $comparison) {
                $comparison = Criteria::IN;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::NOTA_ZA_UTRATE_WARTOSCI_DATA_DODANIA, $notaZaUtrateWartosciDataDodania, $comparison);
    }

    /**
     * Filter the query on the prowadzacy_imie column
     *
     * Example usage:
     * <code>
     * $query->filterByProwadzacyImie('fooValue');   // WHERE prowadzacy_imie = 'fooValue'
     * $query->filterByProwadzacyImie('%fooValue%'); // WHERE prowadzacy_imie LIKE '%fooValue%'
     * </code>
     *
     * @param     string $prowadzacyImie The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByProwadzacyImie($prowadzacyImie = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($prowadzacyImie)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $prowadzacyImie)) {
                $prowadzacyImie = str_replace('*', '%', $prowadzacyImie);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::PROWADZACY_IMIE, $prowadzacyImie, $comparison);
    }

    /**
     * Filter the query on the prowadzacy_nazwisko column
     *
     * Example usage:
     * <code>
     * $query->filterByProwadzacyNazwisko('fooValue');   // WHERE prowadzacy_nazwisko = 'fooValue'
     * $query->filterByProwadzacyNazwisko('%fooValue%'); // WHERE prowadzacy_nazwisko LIKE '%fooValue%'
     * </code>
     *
     * @param     string $prowadzacyNazwisko The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByProwadzacyNazwisko($prowadzacyNazwisko = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($prowadzacyNazwisko)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $prowadzacyNazwisko)) {
                $prowadzacyNazwisko = str_replace('*', '%', $prowadzacyNazwisko);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::PROWADZACY_NAZWISKO, $prowadzacyNazwisko, $comparison);
    }

    /**
     * Filter the query on the opis_uszkodzenia column
     *
     * Example usage:
     * <code>
     * $query->filterByOpisUszkodzenia('fooValue');   // WHERE opis_uszkodzenia = 'fooValue'
     * $query->filterByOpisUszkodzenia('%fooValue%'); // WHERE opis_uszkodzenia LIKE '%fooValue%'
     * </code>
     *
     * @param     string $opisUszkodzenia The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByOpisUszkodzenia($opisUszkodzenia = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($opisUszkodzenia)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $opisUszkodzenia)) {
                $opisUszkodzenia = str_replace('*', '%', $opisUszkodzenia);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::OPIS_USZKODZENIA, $opisUszkodzenia, $comparison);
    }

    /**
     * Filter the query on the uwagi column
     *
     * Example usage:
     * <code>
     * $query->filterByUwagi('fooValue');   // WHERE uwagi = 'fooValue'
     * $query->filterByUwagi('%fooValue%'); // WHERE uwagi LIKE '%fooValue%'
     * </code>
     *
     * @param     string $uwagi The value to use as filter.
     *              Accepts wildcards (* and % trigger a LIKE)
     * @param     string $comparison Operator to use for the column comparison, defaults to Criteria::EQUAL
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function filterByUwagi($uwagi = null, $comparison = null)
    {
        if (null === $comparison) {
            if (is_array($uwagi)) {
                $comparison = Criteria::IN;
            } elseif (preg_match('/[\%\*]/', $uwagi)) {
                $uwagi = str_replace('*', '%', $uwagi);
                $comparison = Criteria::LIKE;
            }
        }

        return $this->addUsingAlias(DamagesReportsTotalPeer::UWAGI, $uwagi, $comparison);
    }

    /**
     * Exclude object from result
     *
     * @param   DamagesReportsTotal $reportsTotal Object to remove from the list of results
     *
     * @return DamagesReportsTotalQuery The current query, for fluid interface
     */
    public function prune($reportsTotal = null)
    {
        if ($reportsTotal) {
            $this->addUsingAlias(DamagesReportsTotalPeer::SZKODA_ID, $reportsTotal->getSzkodaId(), Criteria::NOT_EQUAL);
        }

        return $this;
    }

}
